import axios from 'axios'
import { getSaToken } from '@/utils/auth'

// 创建 axios 实例 - OSS文件存储服务
const api = axios.create({
  baseURL: 'http://localhost:5000/oss', // 修改为正确的后端基础路径
  timeout: 30000, // 文件上传需要更长的超时时间
  headers: {
    'Accept': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 获取SaToken信息
    const saToken = getSaToken();
    
    if (saToken && saToken.tokenValue) {
      // 添加satoken请求头
      config.headers['satoken'] = `mezhate ${saToken.tokenValue}`;
    } else {
      // 使用本地存储的token
      const token = localStorage.getItem('token');
      if (token) {
        config.headers['satoken'] = `mezhate ${token}`;
      } else {
        // 即使没有token，也添加satoken头，值为固定格式
        config.headers['satoken'] = `mezhate token`;
      }
    }
    
    return config;
  },
  error => {
    return Promise.reject(error);
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    return response.data
  },
  error => {
    if (error.code === 'ECONNABORTED') {
      return Promise.reject(new Error('文件上传超时，请检查网络连接或减小文件大小'))
    }
    if (error.response) {
      switch (error.response.status) {
        case 401:
          return Promise.reject(new Error('登录已过期，请重新登录'))
        case 403:
          return Promise.reject(new Error('没有文件上传权限'))
        case 404:
          return Promise.reject(new Error('上传服务不存在'))
        case 413:
          return Promise.reject(new Error('文件太大，超出服务器限制'))
        case 500:
          return Promise.reject(new Error('服务器错误'))
        default:
          return Promise.reject(new Error(error.response.data?.message || '文件上传失败'))
      }
    } else if (error.request) {
      return Promise.reject(new Error('网络错误，请检查网络连接'))
    } else {
      return Promise.reject(new Error('请求配置错误'))
    }
  }
)

/**
 * 上传文件到OSS服务
 * @param {FormData} formData - 包含文件和元数据的表单数据
 * @param {Object} options - 上传选项
 * @param {string} options.objectName - 对象名称，格式应为"用户名/功能/随机数"
 * @param {Function} options.onProgress - 上传进度回调函数
 * @returns {Promise} - 上传结果
 */
export const uploadFile = (formData, options = {}) => {
  // 创建特殊的请求配置，用于文件上传
  const config = {
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  };
  
  // 如果有进度回调，添加到配置中
  if (options.onProgress) {
    config.onUploadProgress = (progressEvent) => {
      const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total);
      options.onProgress(percentCompleted);
    };
  }
  
  // 准备FormData，确保参数与后端API匹配
  const apiFormData = new FormData();
  
  // 处理文件参数 - 后端API期望参数名为'uploadFile'
  const file = formData.get('file') || formData.get('avatar');
  if (file) {
    apiFormData.append('uploadFile', file);
  }
  
  // 添加objectName参数 - 直接使用传入的值，不做额外处理
  const objectName = options.objectName || 'anonymous/default';
  apiFormData.append('objectName', objectName);
  
  // 从objectName中提取用户名部分用于本地存储
  // 格式可能是 "用户名/avatar/随机数"，只取第一段作为用户名
  const parts = objectName.split('/');
  const userName = parts[0] || 'anonymous';
  const fileType = parts.length > 1 ? parts[1] : 'default';
  
  // 构建存储的键名 - 对于头像统一使用"avatar_用户名"格式
  let storageKey;
  if (formData.get('avatar') || fileType === 'avatar') {
    storageKey = `avatar_${userName}`;
  } else {
    storageKey = `file_${userName}_${Date.now()}`;
  }
  
  console.log('上传参数:', {
    objectName: objectName,
    hasFile: !!file,
    userName: userName,
    storageKey: storageKey
  });
  
  // 尝试调用真实API
  try {
    // 根据后端API路径调整请求地址
    return api.post('/upload', apiFormData, config)
      .then(response => {
        console.log('上传响应:', response);
        
        // 处理后端返回的URL
        if (response.success || response.code === 200) {
          // 后端可能直接返回URL字符串或包含在data对象中
          const fileUrl = typeof response.data === 'string' ? response.data : response.data?.url || response.data || '';
          
          // 如果是头像上传模式，将URL存储在localStorage中
          if (formData.get('avatar') || fileType === 'avatar') {
            localStorage.setItem(storageKey, fileUrl);
          }
          
          return {
            success: true,
            message: '文件上传成功',
            data: {
              fileUrl: fileUrl,
              fileName: file ? file.name : '',
              fileSize: file ? file.size : 0,
              uploadTime: new Date().toISOString()
            }
          };
        }
        return response;
      })
      .catch(error => {
        console.warn('文件上传API调用失败，使用模拟数据', error);
        
        // 如果API失败，使用模拟实现
        return new Promise((resolve) => {
          // 模拟上传进度
          if (options.onProgress) {
            let progress = 0;
            const progressInterval = setInterval(() => {
              progress += 10;
              options.onProgress(progress > 100 ? 100 : progress);
              if (progress >= 100) {
                clearInterval(progressInterval);
              }
            }, 200);
          }
          
          setTimeout(() => {
            // 创建本地URL
            const fileUrl = file ? URL.createObjectURL(file) : '';
            
            // 将URL存储在localStorage中，模拟持久化
            if (fileUrl) {
              localStorage.setItem(storageKey, fileUrl);
            }
            
            resolve({
              success: true,
              message: '文件上传成功（模拟模式）',
              data: {
                fileUrl: fileUrl,
                fileName: file ? file.name : '',
                fileSize: file ? file.size : 0,
                uploadTime: new Date().toISOString()
              }
            });
          }, 1500);
        });
      });
  } catch (error) {
    console.error('文件上传API调用出错:', error);
    return Promise.reject(error);
  }
}

/**
 * 上传头像（特殊的文件上传）
 * @param {FormData} formData - 包含头像和用户信息的表单数据
 * @param {Object} options - 上传选项
 * @param {string} options.objectName - 对象名称，格式应为"用户名/avatar"
 * @returns {Promise} - 上传结果
 */
export const uploadAvatar = (formData, options = {}) => {
  // 确保formData中包含avatar字段
  if (!formData.has('avatar') && formData.has('file')) {
    const file = formData.get('file');
    formData.delete('file');
    formData.append('avatar', file);
  }
  
  // 传递原始选项，不再修改objectName
  console.log('上传头像选项:', options);
  
  return uploadFile(formData, options)
    .then(response => {
      // 处理avatar特定的响应格式
      if (response.success) {
        return {
          ...response,
          data: {
            ...response.data,
            avatarUrl: response.data.fileUrl
          }
        };
      }
      return response;
    });
}

/**
 * 删除文件
 * @param {Object} params - 删除参数
 * @param {string} params.fileUrl - 文件URL
 * @param {string} params.userName - 用户名
 * @returns {Promise} - 删除结果
 */
export const deleteFile = (params) => {
  if (!params.fileUrl) {
    return Promise.reject(new Error('删除文件失败: 未提供文件URL'));
  }
  
  // 尝试调用真实API
  try {
    // 使用与上传相同的路径结构
    return api.post('/delete', params)
      .catch(error => {
        console.warn('删除文件API调用失败，使用模拟数据', error);
        
        // 如果API失败，使用模拟实现
        return new Promise((resolve) => {
          setTimeout(() => {
            resolve({
              success: true,
              message: '文件已删除（模拟模式）',
              data: null
            });
          }, 500);
        });
      });
  } catch (error) {
    console.error('删除文件API调用出错:', error);
    return Promise.reject(error);
  }
}

/**
 * 删除头像
 * @param {string} userName - 用户名
 * @returns {Promise} - 删除结果
 */
export const removeAvatar = (userName) => {
  if (!userName) {
    return Promise.reject(new Error('删除头像失败: 未提供用户名'));
  }
  
  // 用户名作为localStorage的存储键
  const storageKey = `avatar_${userName}`;
  
  // 尝试调用真实API
  try {
    // 使用基本路径结构，不指定具体的随机数
    // 后端需要支持删除该路径下的所有文件或最新的文件
    return api.post('/deleteAvatar', { 
      userName,
      objectName: `${userName}/avatar` // 基本路径，不包含随机数
    })
      .catch(error => {
        console.warn('删除头像API调用失败，使用模拟数据', error);
        
        // 如果API失败，使用模拟实现
        return new Promise((resolve) => {
          setTimeout(() => {
            // 从localStorage中删除头像URL
            localStorage.removeItem(storageKey);
            
            resolve({
              success: true,
              message: '头像已删除（模拟模式）',
              data: null
            });
          }, 500);
        });
      });
  } catch (error) {
    console.error('删除头像API调用出错:', error);
    return Promise.reject(error);
  }
} 